// controllers/deepseekAiController.js
const axios = require('axios');

// DeepSeek API配置
const DEEPSEEK_API_KEY = process.env.DEEPSEEK_API_KEY || '';
const DEEPSEEK_API_BASE_URL = 'https://api.deepseek.com/v1';

// 检查API Key是否配置
if (!DEEPSEEK_API_KEY) {
  console.warn('警告：DEEPSEEK_API_KEY未配置，AI功能将无法使用');
}

// 请求头配置
const headers = {
  'Content-Type': 'application/json',
  'Authorization': `Bearer ${DEEPSEEK_API_KEY}`
};

/**
 * AI文本润色功能
 * @param {string} text - 需要润色的文本
 */
async function polishText(text) {
  if (!DEEPSEEK_API_KEY) {
    throw new Error('DEEPSEEK_API_KEY未配置');
  }

  try {
    const response = await axios.post(`${DEEPSEEK_API_BASE_URL}/chat/completions`, {
      model: 'deepseek-chat',
      messages: [
        {
          role: 'system',
          content: '你是一个专业的文本润色助手，请将用户提供的文本进行润色，使其更加流畅、专业和清晰，但不要改变原意。'
        },
        {
          role: 'user',
          content: `请润色以下文本：${text}`
        }
      ],
      temperature: 0.7,
      max_tokens: 1000
    }, { headers });

    // 提取润色后的文本
    const polishedText = response.data.choices && response.data.choices[0] && response.data.choices[0].message 
      ? response.data.choices[0].message.content 
      : '无法获取润色结果';
    
    return polishedText;
  } catch (error) {
    console.error('文本润色失败:', error.response ? error.response.data : error.message);
    throw new Error('文本润色失败');
  }
}

/**
 * AI评价打分功能
 * @param {string} knowledgePoint - 知识点
 * @param {string} userAnswer - 用户回答
 */
async function evaluateAnswer(knowledgePoint, userAnswer) {
  if (!DEEPSEEK_API_KEY) {
    throw new Error('DEEPSEEK_API_KEY未配置');
  }

  try {
    const response = await axios.post(`${DEEPSEEK_API_BASE_URL}/chat/completions`, {
      model: 'deepseek-chat',
      messages: [
        {
          role: 'system',
          content: `你是一个专业的教育评价助手，请根据提供的知识点和用户回答，给出评价、打分和建议。
          
请严格按照以下JSON格式返回结果，不要包含任何额外的解释或文字：
{
  "polished_answer": "润色后的用户回答",
  "evaluation": "对用户回答的综合评价",
  "strengths": ["优点1", "优点2"],
  "weaknesses": ["待改进点1", "待改进点2"],
  "score": 85
}`
        },
        {
          role: 'user',
          content: `知识点：${knowledgePoint}

用户回答：${userAnswer}

请根据知识点评价用户回答，并按照要求的JSON格式返回结果。`
        }
      ],
      temperature: 0.3,
      max_tokens: 1500,
      response_format: { type: 'json_object' }
    }, { headers });

    // 尝试解析JSON响应
    let result;
    try {
      const content = response.data.choices[0].message.content;
      result = JSON.parse(content);
    } catch (parseError) {
      console.error('JSON解析失败:', parseError.message);
      console.log('原始响应内容:', response.data.choices[0].message.content);
      throw new Error('AI返回的结果格式不正确');
    }

    return {
      polishedAnswer: result.polished_answer,
      evaluation: result.evaluation,
      strengths: result.strengths || [],
      weaknesses: result.weaknesses || [],
      score: result.score
    };
  } catch (error) {
    console.error('评价失败:', error.response ? error.response.data : error.message);
    throw new Error('评价失败');
  }
}

/**
 * AI生成题目功能
 * @param {string} knowledgePointContent - 知识点内容
 * @param {string} difficulty - 难度等级
 * @param {string} type - 题目类型 (single-choice, short-answer)
 */
async function generateQuestion(knowledgePointContent, difficulty, type = 'single-choice') {
  if (!DEEPSEEK_API_KEY) {
    throw new Error('DEEPSEEK_API_KEY未配置');
  }

  try {
    // 根据题目类型选择不同的Prompt
    let prompt;
    if (type === 'single-choice') {
      prompt = `
你是一个专业的计算机科学出题专家。请根据以下提供的知识点内容和指定的难度，生成一个相关的单项选择题。

【知识点内容】:
"""
${knowledgePointContent}
"""

【指定难度】: ${difficulty}  (可选值为: 基础, 中等, 困难)

【出题要求】:
1. 确保题目具有实际意义，与知识点紧密相关
2. 选项设计要合理，有一个正确答案和三个有迷惑性的错误答案
3. 题目内容应该每次都有所变化，避免重复
4. 解释要清晰说明为什么正确选项是对的，其他选项为什么是错的

请严格按照以下JSON格式返回题目，不要包含任何额外的解释或文字，确保所有字段都存在。
{
  "type": "single-choice",
  "difficulty": "${difficulty}",
  "question": "这里是题干",
  "options": {
    "A": "选项A的内容",
    "B": "选项B的内容",
    "C": "选项C的内容",
    "D": "选项D的内容"
  },
  "answer": "C",
  "explanation": "这里是对正确答案的简短解释"
}
`;
    } else if (type === 'short-answer') {
      prompt = `
你是一个专业的计算机科学出题专家。请根据以下提供的知识点内容和指定的难度，生成一个相关的简答题。

【知识点内容】:
"""
${knowledgePointContent}
"""

【指定难度】: ${difficulty}  (可选值为: 基础, 中等, 困难)

【出题要求】:
1. 确保题目具有实际意义，与知识点紧密相关
2. 问题应该每次都有所变化，避免重复
3. 答案要点应该清晰明确，便于后续评分

请严格按照以下JSON格式返回题目，不要包含任何额外的解释或文字，确保所有字段都存在。
{
  "type": "short-answer",
  "difficulty": "${difficulty}",
  "question": "这里是题干",
  "answer_key_points": [
    "答案要点1",
    "答案要点2",
    "答案要点3"
  ]
}
`;
    }

    const response = await axios.post(`${DEEPSEEK_API_BASE_URL}/chat/completions`, {
      model: 'deepseek-chat',
      messages: [
        {
          role: 'user',
          content: prompt
        }
      ],
      temperature: 0.8, // 增加随机性，减少重复题目
      max_tokens: 1500,
      response_format: { type: 'json_object' }
    }, { headers });

    // 尝试解析JSON响应
    let result;
    try {
      const content = response.data.choices[0].message.content;
      result = JSON.parse(content);
    } catch (parseError) {
      console.error('JSON解析失败:', parseError.message);
      console.log('原始响应内容:', response.data.choices[0].message.content);
      throw new Error('AI返回的结果格式不正确');
    }

    return result;
  } catch (error) {
    console.error('生成题目失败:', error.response ? error.response.data : error.message);
    throw new Error('生成题目失败: ' + (error.response?.data?.error?.message || error.message));
  }
}

/**
 * AI评分功能（用于简答题）
 * @param {object} question - 题目对象
 * @param {string} studentAnswer - 学生答案
 */
async function gradeAnswer(question, studentAnswer) {
  if (!DEEPSEEK_API_KEY) {
    throw new Error('DEEPSEEK_API_KEY未配置');
  }

  try {
    const prompt = `
你是一个客观的计算机科学阅卷老师。请根据以下题目、答案要点和学生的回答，判断学生的回答是否正确，并给出解释。

【题目】:
${question.question}

【答案要点】:
${question.answer_key_points ? question.answer_key_points.join('\n') : '无'}

【学生的回答】:
${studentAnswer}

请严格按照以下JSON格式返回你的评判结果，不要包含任何额外的解释或文字。
{
  "isCorrect": true,  // 或 false
  "explanation": "这里是你的评判理由，比如：回答基本正确，覆盖了主要区别。或：回答混淆了State和Props的概念。"
}
`;

    const response = await axios.post(`${DEEPSEEK_API_BASE_URL}/chat/completions`, {
      model: 'deepseek-chat',
      messages: [
        {
          role: 'user',
          content: prompt
        }
      ],
      temperature: 0.3,
      max_tokens: 1000,
      response_format: { type: 'json_object' }
    }, { headers });

    // 尝试解析JSON响应
    let result;
    try {
      const content = response.data.choices[0].message.content;
      result = JSON.parse(content);
    } catch (parseError) {
      console.error('JSON解析失败:', parseError.message);
      console.log('原始响应内容:', response.data.choices[0].message.content);
      throw new Error('AI返回的结果格式不正确');
    }

    return result;
  } catch (error) {
    console.error('评分失败:', error.response ? error.response.data : error.message);
    throw new Error('评分失败: ' + (error.response?.data?.error?.message || error.message));
  }
}

// AI润色与评价的核心函数
exports.evaluateFeynmanAttempt = async (req, res) => {
  const { originalContent, transcribedText } = req.body;

  if (!originalContent || !transcribedText) {
    return res.status(400).json({ msg: 'Original content and transcribed text are required.' });
  }

  try {
    // AI评价的核心逻辑
    const evaluationResult = await evaluateAnswer(originalContent, transcribedText);
    
    res.json(evaluationResult);
  } catch (error) {
    console.error('Error calling LLM API:', error.message);
    res.status(500).send('Server error during AI evaluation.');
  }
};

// AI文本润色函数
exports.polishTranscribedText = async (req, res) => {
  const { transcribedText } = req.body;

  if (!transcribedText) {
    return res.status(400).json({ msg: 'Transcribed text is required.' });
  }

  try {
    // AI润色的核心逻辑
    const polishedText = await polishText(transcribedText);
    
    res.json({ polishedText });
  } catch (error) {
    console.error('Error calling LLM API:', error.message);
    res.status(500).send('Server error during AI text polishing.');
  }
};

// AI生成题目函数
exports.generateQuestion = async (req, res) => {
  const { knowledgePointContent, difficulty, type } = req.body;

  if (!knowledgePointContent || !difficulty) {
    return res.status(400).json({ msg: 'Knowledge point content and difficulty are required.' });
  }

  try {
    const questionData = await generateQuestion(knowledgePointContent, difficulty, type);
    res.json(questionData);
  } catch (error) {
    console.error('Error calling LLM API for question generation:', error.message);
    res.status(500).send('Server error during question generation.');
  }
};

// AI评分函数
exports.gradeAnswer = async (req, res) => {
  const { question, studentAnswer } = req.body;

  if (!question || !studentAnswer) {
    return res.status(400).json({ msg: 'Question and student answer are required.' });
  }

  try {
    const gradingResult = await gradeAnswer(question, studentAnswer);
    res.json(gradingResult);
  } catch (error) {
    console.error('Error calling LLM API for grading:', error.message);
    res.status(500).send('Server error during answer grading.');
  }
};